package my.tree;

import my.printer.BinaryTreeInfo;

import java.util.LinkedList;
import java.util.Queue;

/**
 * <p>
 * 二叉树
 * </p>
 *
 * @author AJun
 * @since 2020年8月20日
 */
@SuppressWarnings("ALL")
public abstract class BinaryTree<E> implements BinaryTreeInfo {

    /**
     * 二叉树节点数量
     */
    protected int size;

    /**
     * 二叉树根节点
     */
    protected Node<E> root;

    /**
     * 获取二叉树节点数量
     *
     * @return 二叉树节点数量
     */
    public int size() {
        return size;
    }

    /**
     * 判断此二叉树是否为空
     *
     * @return 此二叉树是否为空（节点数量是否为0）
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 清空二叉树节点
     */
    public void clear() {
        root = null;
        size = 0;
    }

    /**
     * 前序遍历二叉树: 中左右
     *
     * @param visitor 提供给外界自定义遍历逻辑的接口
     */
    public void preorder(Visitor<E> visitor) {
        if (visitor == null) {
            return;
        }

        preorder(root, visitor);
    }

    /**
     * 从某个节点开始前序遍历二叉树
     *
     * @param node    二叉树中的节点
     * @param visitor 提供给外界自定义遍历逻辑的接口
     */
    public void preorder(Node<E> node, Visitor<E> visitor) {
        if (node == null) {
            return;
        }

        visitor.visit(node.element);
        preorder(node.left, visitor);
        preorder(node.right, visitor);
    }

    /**
     * 中序遍历二叉树: 左中右
     *
     * @param visitor 提供给外界自定义遍历逻辑的接口
     */
    public void inorder(Visitor<E> visitor) {
        if (visitor == null) {
            return;
        }

        inorder(root, visitor);
    }

    /**
     * 从某个节点开始中序遍历二叉树
     *
     * @param node    二叉树中的节点
     * @param visitor 提供给外界自定义遍历逻辑的接口
     */
    public void inorder(Node<E> node, Visitor<E> visitor) {
        if (node == null) {
            return;
        }

        inorder(node.left, visitor);
        visitor.visit(node.element);
        inorder(node.right, visitor);
    }

    /**
     * 后序遍历二叉树
     *
     * @param visitor 提供给外界自定义遍历逻辑的接口
     */
    public void postorder(Visitor<E> visitor) {
        if (visitor == null) {
            return;
        }

        postorder(root, visitor);
    }

    /**
     * 从某个节点开始后序遍历二叉树
     *
     * @param node    二叉树中的节点
     * @param visitor 提供给外界自定义遍历逻辑的接口
     */
    public void postorder(Node<E> node, Visitor<E> visitor) {
        if (node == null) {
            return;
        }

        postorder(node.left, visitor);
        postorder(node.right, visitor);
        visitor.visit(node.element);
    }

    /**
     * 层序遍历二叉树
     *
     * @param visitor 提供给外界自定义遍历逻辑的接口
     */
    public void levelOrder(Visitor<E> visitor) {
        if (root == null || visitor == null) {
            return;
        }

        Queue<Node<E>> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            Node<E> front = queue.remove();
            visitor.visit(front.element);

            if (front.left != null) {
                queue.add(front.left);
            }
            if (front.right != null) {
                queue.add(front.right);
            }
        }
    }

    /**
     * 获取二叉树高度: 迭代-层序遍历
     *
     * @return 二叉树高度
     */
    public int heightLevelOrder() {
        return heightLevelOrder(root);
    }

    /**
     * 获取二叉树中某个节点的高度: 迭代-层序遍历
     *
     * @param node 二叉树中的节点
     * @return 此节点的高度
     */
    private int heightLevelOrder(Node<E> node) {
        if (node == null) {
            return 0;
        }

        // 二叉树的高度
        int height = 0;
        // 每一层的元素数量，默认加入了根节点，所以默认为 1
        int levelSize = 1;

        Queue<Node<E>> queue = new LinkedList<>();
        queue.add(node);
        while (!queue.isEmpty()) {
            Node<E> front = queue.remove();

            // 每次访问一个元素，将这一层的元素数量-1，如果元素数量变为0，则说明这一层已经访问完毕
            levelSize--;

            if (front.left != null) {
                queue.add(front.left);
            }
            if (front.right != null) {
                queue.add(front.right);
            }

            // 如果 levelSize == 0，意味即将要访问下一层
            if (levelSize == 0) {
                // 下一层的高度就是队列的长度
                levelSize = queue.size();
                height++;
            }
        }
        return height;
    }

    /**
     * 获取二叉树高度: 递归
     *
     * @return 二叉树高度
     */
    public int height() {
        return height(root);
    }

    /**
     * 获取二叉树中某个节点的高度: 递归
     *
     * @param node 二叉树中的节点
     * @return 此节点的高度
     */
    private int height(Node<E> node) {
        if (node == null) {
            return 0;
        }

        return 1 + Math.max(height(node.left), height(node.right));
    }

    /**
     * 判断二叉树是否是一棵完全二叉树
     *
     * @return true: 是; false: 不是
     */
    public boolean isComplete() {
        if (root == null) {
            return false;
        }

        // 标记: 是否为叶子节点
        boolean leaf = false;

        Queue<Node<E>> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            Node<E> front = queue.remove();

            // 如果要求此节点必须是叶子节点，但此节点实际并不是叶子节点，则它不是完全二叉树
            if (leaf && front.isLeaf()) {
                return false;
            }

            if (front.left != null) {
                queue.add(front.left);
            } else if (front.right != null) {
                // 左为空而右不为空，不是完全二叉树
                return false;
            }

            if (front.right != null) {
                queue.add(front.right);
            } else {
                // 右为空，说明之后遍历的节点都必须是叶子节点
                leaf = true;
            }
        }
        return true;
    }

    /**
     * 获取传入节点的前驱节点
     *
     * @param node 二叉树节点
     * @return 此节点的前驱节点
     */
    protected Node<E> predecessor(Node<E> node) {
        if (node == null) {
            return null;
        }

        // 前驱节点在左子树中，即此节点的左子节点的最后一个右子节点(node.left.right.right...)
        Node<E> p = node.left;
        if (p != null) {
            while (p.right != null) {
                p = p.right;
            }
            return p;
        }

        // 左子树为空，前驱节点是此节点的父节点或祖父节点
        // 如果父节点不为空 且 父节点的左子树是此节点，则一直往上找父节点
        while (node.parent != null && (node == node.parent.left)) {
            node = node.parent;
        }

        // 没找到父节点(node.parent == null) 或 父节点的右子节点是此节点(node == node.parent.right)
        return node.parent;
    }

    /**
     * 获取传入节点的后继节点
     *
     * @param node 二叉树节点
     * @return 此节点的后继节点
     */
    protected Node<E> successor(Node<E> node) {
        if (node == null) {
            return null;
        }

        // 前驱节点在右子树中，即此节点的右子节点的最后一个左子节点(node.right.left.left...)
        Node<E> p = node.right;
        if (p != null) {
            while (p.left != null) {
                p = p.left;
            }
            return p;
        }

        // 左子树为空，前驱节点是此节点的父节点或祖父节点
        // 如果父节点不为空 且 父节点的左子树是此节点，则一直往上找父节点
        while (node.parent != null && (node == node.parent.right)) {
            node = node.parent;
        }

        // 没找到父节点(node.parent == null) 或 父节点的左子节点是此节点(node == node.parent.left)
        return node.parent;
    }

    /**
     * 创建二叉树节点
     *
     * @param element 节点的元素内容
     * @param parent  节点的父节点
     * @return 二叉树节点
     */
    protected Node<E> createNode(E element, Node<E> parent) {
        return new Node<>(element, parent);
    }

    /**
     * 提供给外界自定义遍历逻辑的接口
     */
    public interface Visitor<E> {
        /**
         * 自定义遍历逻辑
         *
         * @param element 当前节点存储的元素
         */
        void visit(E element);
    }

    /**
     * 二叉树节点
     */
    protected static class Node<E> {
        /**
         * 节点元素
         */
        E element;

        /**
         * 父节点
         */
        Node<E> parent;

        /**
         * 左子节点
         */
        Node<E> left;

        /**
         * 右子节点
         */
        Node<E> right;

        /**
         * 有参构造
         *
         * @param element 节点存储的元素
         * @param parent  此节点的父节点
         */
        public Node(E element, Node<E> parent) {
            this.element = element;
            this.parent = parent;
        }

        /**
         * 判断节点是否是叶子节点
         *
         * @return true: 是; false: 不是
         */
        public boolean isLeaf() {
            return left == null && right == null;
        }

        /**
         * 判断节点左右都不为空，即有俩个子节点
         *
         * @return true: 是; false: 不是
         */
        public boolean hasTwoChildren() {
            return left != null && right != null;
        }

        /**
         * 判断当前节点是否是父节点的左子树
         *
         * @return true: 是; false: 不是
         */
        public boolean isLeftChild() {
            return parent != null && this == parent.left;
        }

        /**
         * 判断当前节点是否是父节点的右子树
         *
         * @return true: 是; false: 不是
         */
        public boolean isRightChild() {
            return parent != null && this == parent.right;
        }

        /**
         * 获取该节点的兄弟节点
         *
         * @return 该节点的兄弟节点
         */
        public Node<E> sibling() {
            if (isLeftChild()) {
                return parent.right;
            }
            if (isRightChild()) {
                return parent.left;
            }
            // 没有父节点，即: 没有兄弟节点
            return null;
        }
    }

    /* 二叉树打印器 */
    @Override
    public Object root() {
        return root;
    }

    @Override
    public Object left(Object node) {
        return ((Node<E>) node).left;
    }

    @Override
    public Object right(Object node) {
        return ((Node<E>) node).right;
    }

    @Override
    public Object string(Object node) {
        /*Node<E> n = (Node<E>) node;
        String parentStr = "null";
        if (n.parent != null)
            parentStr = n.parent.element.toString();
        return n.element + "(parent => " + parentStr + ")";*/
        return node;
    }

}
